Creating valuable application programs requires more than just programming ability. There is an increasing appreciation for the need for aesthetics and ease of use in the design of user interfaces. To term the new user interfaces design strategies in cutting edge software as being “ergonomic” is not an overstatement. The rapid rate of obsolescence in software has further increased the pressure to create increasingly sophisticated application programs complete with bug free code and friendly interfaces in a short period of time or risk missing the small window of economic opportunity.
A traditional application program includes source code, usually, organized in several modules defined by different roles in the program's logical layout. Following compilation, these modules are linked to form an executable program. This simplistic picture is modified significantly in the modern programming paradigm. Thus, in the popular “WINDOWS®” operating system environment found in operating systems manufactured by the “MICROSOFT®” corporation of Redmond, Wash., application development typically requires generation of several different files types that cooperate to give effect to an application.
A “WINDOWS®” application program typically has an executable file that creates, directly or indirectly by making appropriate calls, one or more “WINDOWS®” elements to implement a user interface. In addition, the placement and appearance of these elements is expected to conform to rules in agreement with certain styles. Such styles include, e.g., “The WINDOWS® Interface Guidelines for Software Design” published in 1995 by the MICROSOFT® Press,” ISBN 1-55615-679-0.
In addition, unlike earlier programming paradigms, in a “WINDOWS®” environment, there are files with code modules such as dynamic link library (DLL) files, resource files, library files and other file types that are used to generate an application. A respectable application may depend on thousands of files to handle the different scenarios that may develop in course of its execution. Of particular interest are the resource files that include information relevant to the design and implementation of the graphical elements shown on the screen, and even multimedia interactivity.
Although resource files contain data, such as parameters, bitmaps for icons, font and color choices and the like for rendering graphical symbols, they cannot be treated as merely data files that may be accessed at runtime due to their dynamic use in giving effect to the user interface. Some user interface elements, i.e., “WINDOWS®” elements, of interest include dialog boxes, message boxes, drop-down lists, menus, toolbars and even audio effects. Each user interface element needs to be invoked at the right time and place with modifications for accomplishing a particular purpose, and at the same time it is expected to conform to a style or deviate from it for a reason.
Some user interface elements convey information to the user while others also collect information, and all, preferably, add to the experience of the user. The placement and details of the design implementation are preferably controlled by parameters supplied in resource files, which may be edited with the help of programming tools and resource editors, available in some environments, or by directly modifying the application source code.
This, in turn, has resulted in focusing attention on the process of designing and developing application programs. As may be expected, cost is an important consideration in the development of improved computer programs. Programmers skilled in writing code for applications are expensive, and programmers having an additional feel for the aesthetic needs of the ordinary consumer are even more precious. Consequently, in developing an application a division of labor between the “designers” and the “developers” has proven to be cost effective. Developers specialize in coding, debugging and similar programming related tasks while “designers” are so designated due to their skill in designing the look and feel of an application. Many designers lack the coding prowess of the average developer and conversely, many developers lack the presentation skills that a designer brings to the job.
One of the strategies in designing user interfaces is to make the interface predictable, i.e., conform to a style while draw attention to other parts of the interface by drawing attention to it due to failure to conform to a style or user expectation. Thus, a designer would be expected to pick and choose which of the style rules to follow or modify. On the other hand, use of the programming tools and editors requires considerable training and technical knowledge since, potentially, rest of the application source code could be corrupted by what may appear to be minor errors to the uninitiated.
A common difficulty in managing such a diverse team is the need for the developers to implement the smallest changes made by the designers as they experiment with different layouts. Each time the designers try out a new look in course of settling on an effective layout, the developers modify the application code, compile and link the code and then call on the designers to evaluate the result. This is an expensive operation.
Apart from the need for countless meetings between designers and developers, the time taken in developing an application includes several cycles, termed “build,” each build typically taking two to three days. At the end of a build the different component parts of an application are ready to be operated together (as opposed to being tested separately. Thus, desirable management of the application development process preferably reduces the tedium for the developers while leaving the designers unfettered and, at the same time, reducing costs and the time required for getting the application ready for shipping.
Another situation that results in the need for modifying primarily the user interface in an otherwise finished application is while porting the application from one linguistic and cultural context to another. This may result in changes in the style, size, associated text and appearance of the graphical controls to accommodate text, larger or smaller fonts, handedness, different designs and the like. Some of these changes are predictable within a particular context, while other changes require insight and skill to generate an effective presentation in the new context. Advantageously, it is possible to make many of the changes without requiring developer input. An application for a U.S. patent application Ser. No. 09/452,421, filed on Dec. 1, 1999 teaches a method and system for making resource files external to application programs such that changes to the resource files can be made by the designers in a markup language with the aid of suitable tools without necessarily requiring developer input and is incorporated in its entirety by reference. This still leaves much to be done by the designers as they provide initialization parameters, details for the relative placement of controls and other mundane tasks in course of giving shape to a user interface.